home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / share / pygtk / 2.0 / codegen / reversewrapper.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2006-01-20  |  28KB  |  715 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. import argtypes
  5.  
  6. def join_ctype_name(ctype, name):
  7.     '''Joins a C type and a variable name into a single string'''
  8.     if ctype[-1] != '*':
  9.         return ' '.join((ctype, name))
  10.     else:
  11.         return ''.join((ctype, name))
  12.  
  13.  
  14. class CodeSink(object):
  15.     
  16.     def __init__(self):
  17.         self.indent_level = 0
  18.         self.indent_stack = []
  19.  
  20.     
  21.     def _format_code(self, code):
  22.         if not isinstance(code, str):
  23.             raise AssertionError
  24.         l = []
  25.         for line in code.split('\n'):
  26.             l.append(' ' * self.indent_level + line)
  27.         
  28.         if l[-1]:
  29.             l.append('')
  30.         
  31.         return '\n'.join(l)
  32.  
  33.     
  34.     def writeln(self, line = ''):
  35.         raise NotImplementedError
  36.  
  37.     
  38.     def indent(self, level = 4):
  39.         '''Add a certain ammount of indentation to all lines written
  40.         from now on and until unindent() is called'''
  41.         self.indent_stack.append(self.indent_level)
  42.         self.indent_level += level
  43.  
  44.     
  45.     def unindent(self):
  46.         '''Revert indentation level to the value before last indent() call'''
  47.         self.indent_level = self.indent_stack.pop()
  48.  
  49.  
  50.  
  51. class FileCodeSink(CodeSink):
  52.     
  53.     def __init__(self, fp):
  54.         CodeSink.__init__(self)
  55.         if not isinstance(fp, file):
  56.             raise AssertionError
  57.         self.fp = fp
  58.  
  59.     
  60.     def writeln(self, line = ''):
  61.         self.fp.write(self._format_code(line))
  62.  
  63.  
  64.  
  65. class MemoryCodeSink(CodeSink):
  66.     
  67.     def __init__(self):
  68.         CodeSink.__init__(self)
  69.         self.lines = []
  70.  
  71.     
  72.     def writeln(self, line = ''):
  73.         self.lines.append(self._format_code(line))
  74.  
  75.     
  76.     def flush_to(self, sink):
  77.         if not isinstance(sink, CodeSink):
  78.             raise AssertionError
  79.         for line in self.lines:
  80.             sink.writeln(line.rstrip())
  81.         
  82.         self.lines = []
  83.  
  84.     
  85.     def flush(self):
  86.         l = []
  87.         for line in self.lines:
  88.             l.append(self._format_code(line))
  89.         
  90.         self.lines = []
  91.         return ''.join(l)
  92.  
  93.  
  94.  
  95. class ReverseWrapper(object):
  96.     '''Object that generates a C->Python wrapper'''
  97.     
  98.     def __init__(self, cname, is_static = True):
  99.         if not isinstance(cname, str):
  100.             raise AssertionError
  101.         self.cname = cname
  102.         self.called_pyobj = None
  103.         self.method_name = None
  104.         self.is_static = is_static
  105.         self.parameters = []
  106.         self.declarations = MemoryCodeSink()
  107.         self.body = MemoryCodeSink()
  108.         self.cleanup_actions = []
  109.         self.pyargv_items = []
  110.         self.pyargv_optional_items = []
  111.  
  112.     
  113.     def set_call_target(self, called_pyobj, method_name = None):
  114.         if not called_pyobj is not None:
  115.             raise AssertionError
  116.         if not self.called_pyobj is None:
  117.             raise AssertionError
  118.         self.called_pyobj = called_pyobj
  119.         self.method_name = method_name
  120.  
  121.     
  122.     def set_return_type(self, return_type):
  123.         if not isinstance(return_type, ReturnType):
  124.             raise AssertionError
  125.         self.return_type = return_type
  126.  
  127.     
  128.     def add_parameter(self, param):
  129.         if not isinstance(param, Parameter):
  130.             raise AssertionError
  131.         self.parameters.append(param)
  132.  
  133.     
  134.     def add_declaration(self, decl_code):
  135.         self.declarations.writeln(decl_code)
  136.  
  137.     
  138.     def add_pyargv_item(self, variable, optional = False):
  139.         if optional:
  140.             self.pyargv_optional_items.append(variable)
  141.         else:
  142.             self.pyargv_items.append(variable)
  143.  
  144.     
  145.     def write_code(self, code, cleanup = None, failure_expression = None, failure_cleanup = None):
  146.         '''Add a chunk of code with cleanup and error handling
  147.  
  148.         This method is to be used by TypeHandlers when generating code
  149.  
  150.         Keywork arguments:
  151.         code -- code to add
  152.         cleanup -- code to cleanup any dynamic resources created by @code
  153.                    (except in case of failure) (default None)
  154.         failure_expression -- C boolean expression to indicate
  155.                               if anything failed (default None)
  156.         failure_cleanup -- code to cleanup any dynamic resources
  157.                            created by @code in case of failure (default None)
  158.         '''
  159.         if code is not None:
  160.             self.body.writeln(code)
  161.         
  162.         if failure_expression is not None:
  163.             self.body.writeln('if (%s) {' % failure_expression)
  164.             self.body.indent()
  165.             self.body.writeln('if (PyErr_Occurred())')
  166.             self.body.indent()
  167.             self.body.writeln('PyErr_Print();')
  168.             self.body.unindent()
  169.             if failure_cleanup is not None:
  170.                 self.body.writeln(failure_cleanup)
  171.             
  172.             for cleanup_action in self.cleanup_actions:
  173.                 self.body.writeln(cleanup_action)
  174.             
  175.             self.return_type.write_error_return()
  176.             self.body.unindent()
  177.             self.body.writeln('}')
  178.         
  179.         if cleanup is not None:
  180.             self.cleanup_actions.insert(0, cleanup)
  181.         
  182.  
  183.     
  184.     def generate(self, sink):
  185.         '''Generate the code into a CodeSink object'''
  186.         if not isinstance(sink, CodeSink):
  187.             raise AssertionError
  188.         self.add_declaration('PyGILState_STATE __py_state;')
  189.         self.write_code(code = '__py_state = pyg_gil_state_ensure();', cleanup = 'pyg_gil_state_release(__py_state);')
  190.         for param in self.parameters:
  191.             param.convert_c2py()
  192.         
  193.         if not self.called_pyobj is not None:
  194.             raise AssertionError, 'Parameters failed to provide a target function or method.'
  195.         if self.is_static:
  196.             sink.writeln('static %s' % self.return_type.get_c_type())
  197.         else:
  198.             sink.writeln(self.return_type.get_c_type())
  199.         c_proto_params = map(Parameter.format_for_c_proto, self.parameters)
  200.         sink.writeln('%s(%s)\n{' % (self.cname, ', '.join(c_proto_params)))
  201.         self.return_type.write_decl()
  202.         self.add_declaration('PyObject *py_retval;')
  203.         if self.pyargv_items:
  204.             self.add_declaration('PyObject *py_args;')
  205.             py_args = 'py_args'
  206.             if self.pyargv_optional_items:
  207.                 self.add_declaration('int argc = %i;' % len(self.pyargv_items))
  208.                 argc = 'argc'
  209.                 for arg in self.pyargv_optional_items:
  210.                     self.body.writeln('if (%s)' % arg)
  211.                     self.body.indent()
  212.                     self.body.writeln('++argc;')
  213.                     self.body.unindent()
  214.                 
  215.             else:
  216.                 argc = str(len(self.pyargv_items))
  217.         elif self.pyargv_optional_items:
  218.             self.add_declaration('PyObject *py_args;')
  219.             py_args = 'py_args'
  220.             self.add_declaration('int argc = 0;')
  221.             argc = 'argc'
  222.             for arg in self.pyargv_optional_items:
  223.                 self.body.writeln('if (%s)' % arg)
  224.                 self.body.indent()
  225.                 self.body.writeln('++argc;')
  226.                 self.body.unindent()
  227.             
  228.         else:
  229.             py_args = 'NULL'
  230.             argc = None
  231.         self.body.writeln()
  232.         if py_args != 'NULL':
  233.             self.write_code('py_args = PyTuple_New(%s);' % argc, cleanup = 'Py_DECREF(py_args);')
  234.             pos = 0
  235.             for arg in self.pyargv_items:
  236.                 
  237.                 try:
  238.                     self.cleanup_actions.remove('Py_DECREF(%s);' % arg)
  239.                 except ValueError:
  240.                     self.body.writeln('Py_INCREF(%s);' % arg)
  241.  
  242.                 self.body.writeln('PyTuple_SET_ITEM(%s, %i, %s);' % (py_args, pos, arg))
  243.                 pos += 1
  244.             
  245.             for arg in self.pyargv_optional_items:
  246.                 self.body.writeln('if (%s) {' % arg)
  247.                 self.body.indent()
  248.                 
  249.                 try:
  250.                     self.cleanup_actions.remove('Py_XDECREF(%s);' % arg)
  251.                 except ValueError:
  252.                     self.body.writeln('Py_INCREF(%s);' % arg)
  253.  
  254.                 self.body.writeln('PyTuple_SET_ITEM(%s, %i, %s);' % (py_args, pos, arg))
  255.                 self.body.unindent()
  256.                 self.body.writeln('}')
  257.                 pos += 1
  258.             
  259.         
  260.         self.body.writeln()
  261.         if self.method_name is None:
  262.             self.write_code('py_retval = PyObject_Call(%s, %s);' % (self.called_pyobj, py_args), cleanup = 'Py_DECREF(py_retval);', failure_expression = '!py_retval')
  263.         else:
  264.             self.add_declaration('PyObject *py_method;')
  265.             self.write_code('py_method = PyObject_GetAttrString(%s, "%s");' % (self.called_pyobj, self.method_name), cleanup = 'Py_DECREF(py_method);', failure_expression = '!py_method')
  266.             self.write_code('py_retval = PyObject_CallObject(py_method, %s);' % (py_args,), cleanup = 'Py_DECREF(py_retval);', failure_expression = '!py_retval')
  267.         self.return_type.write_conversion()
  268.         sink.indent()
  269.         self.declarations.flush_to(sink)
  270.         sink.writeln()
  271.         self.body.flush_to(sink)
  272.         sink.writeln()
  273.         for cleanup_action in self.cleanup_actions:
  274.             sink.writeln(cleanup_action)
  275.         
  276.         if self.return_type.get_c_type() != 'void':
  277.             sink.writeln()
  278.             sink.writeln('return retval;')
  279.         
  280.         sink.unindent()
  281.         sink.writeln('}')
  282.  
  283.  
  284.  
  285. class TypeHandler(object):
  286.     
  287.     def __init__(self, wrapper, **props):
  288.         if not isinstance(wrapper, ReverseWrapper):
  289.             raise AssertionError
  290.         self.wrapper = wrapper
  291.         self.props = props
  292.  
  293.  
  294.  
  295. class ReturnType(TypeHandler):
  296.     
  297.     def get_c_type(self):
  298.         raise NotImplementedError
  299.  
  300.     
  301.     def write_decl(self):
  302.         raise NotImplementedError
  303.  
  304.     
  305.     def write_error_return(self):
  306.         '''Write "return <value>" code in case of error'''
  307.         raise NotImplementedError
  308.  
  309.     
  310.     def write_conversion(self):
  311.         """Writes code to convert Python return value in 'py_retval'
  312.         into C 'retval'.  Returns a string with C boolean expression
  313.         that determines if anything went wrong. """
  314.         raise NotImplementedError
  315.  
  316.  
  317.  
  318. class Parameter(TypeHandler):
  319.     
  320.     def __init__(self, wrapper, name, **props):
  321.         TypeHandler.__init__(self, wrapper, **props)
  322.         self.name = name
  323.  
  324.     
  325.     def get_c_type(self):
  326.         raise NotImplementedError
  327.  
  328.     
  329.     def convert_c2py(self):
  330.         '''Write some code before calling the Python method.'''
  331.         pass
  332.  
  333.     
  334.     def format_for_c_proto(self):
  335.         return join_ctype_name(self.get_c_type(), self.name)
  336.  
  337.  
  338.  
  339. class StringParam(Parameter):
  340.     
  341.     def get_c_type(self):
  342.         return self.props.get('c_type', 'char *').replace('const-', 'const ')
  343.  
  344.     
  345.     def convert_c2py(self):
  346.         if self.props.get('optional', False):
  347.             self.wrapper.add_declaration('PyObject *py_%s = NULL;' % self.name)
  348.             self.wrapper.write_code(code = 'if (%s)\n    py_%s = PyString_FromString(%s);\n' % (self.name, self.name, self.name), cleanup = 'Py_XDECREF(py_%s);' % self.name)
  349.             self.wrapper.add_pyargv_item('py_%s' % self.name, optional = True)
  350.         else:
  351.             self.wrapper.add_declaration('PyObject *py_%s;' % self.name)
  352.             self.wrapper.write_code(code = 'py_%s = PyString_FromString(%s);' % (self.name, self.name), cleanup = 'Py_DECREF(py_%s);' % self.name, failure_expression = '!py_%s' % self.name)
  353.             self.wrapper.add_pyargv_item('py_%s' % self.name)
  354.  
  355.  
  356. for ctype in ('char*', 'gchar*', 'const-char*', 'char-const*', 'const-gchar*', 'gchar-const*', 'string', 'static_string'):
  357.     argtypes.matcher.register_reverse(ctype, StringParam)
  358.  
  359.  
  360. class StringReturn(ReturnType):
  361.     
  362.     def get_c_type(self):
  363.         return 'char *'
  364.  
  365.     
  366.     def write_decl(self):
  367.         self.wrapper.add_declaration('char *retval;')
  368.  
  369.     
  370.     def write_error_return(self):
  371.         self.wrapper.write_code('return NULL;')
  372.  
  373.     
  374.     def write_conversion(self):
  375.         self.wrapper.write_code(code = None, failure_expression = '!PyString_Check(py_retval)', failure_cleanup = 'PyErr_SetString(PyExc_TypeError, "retval should be a string");')
  376.         self.wrapper.write_code('retval = g_strdup(PyString_AsString(py_retval));')
  377.  
  378.  
  379. for ctype in ('char*', 'gchar*'):
  380.     argtypes.matcher.register_reverse(ctype, StringReturn)
  381.  
  382.  
  383. class VoidReturn(ReturnType):
  384.     
  385.     def get_c_type(self):
  386.         return 'void'
  387.  
  388.     
  389.     def write_decl(self):
  390.         pass
  391.  
  392.     
  393.     def write_error_return(self):
  394.         self.wrapper.write_code('return;')
  395.  
  396.     
  397.     def write_conversion(self):
  398.         self.wrapper.write_code(code = None, failure_expression = 'py_retval != Py_None', failure_cleanup = 'PyErr_SetString(PyExc_TypeError, "retval should be None");')
  399.  
  400.  
  401. argtypes.matcher.register_reverse_ret('void', VoidReturn)
  402. argtypes.matcher.register_reverse_ret('none', VoidReturn)
  403.  
  404. class GObjectParam(Parameter):
  405.     
  406.     def get_c_type(self):
  407.         return self.props.get('c_type', 'GObject *')
  408.  
  409.     
  410.     def convert_c2py(self):
  411.         self.wrapper.add_declaration('PyObject *py_%s = NULL;' % self.name)
  412.         self.wrapper.write_code(code = 'if (%s)\n    py_%s = pygobject_new((GObject *) %s);\nelse {\n    Py_INCREF(Py_None);\n    py_%s = Py_None;\n}' % (self.name, self.name, self.name, self.name), cleanup = 'Py_DECREF(py_%s);' % self.name)
  413.         self.wrapper.add_pyargv_item('py_%s' % self.name)
  414.  
  415.  
  416. argtypes.matcher.register_reverse('GObject*', GObjectParam)
  417.  
  418. class GObjectReturn(ReturnType):
  419.     
  420.     def get_c_type(self):
  421.         return self.props.get('c_type', 'GObject *')
  422.  
  423.     
  424.     def write_decl(self):
  425.         self.wrapper.add_declaration('%s retval;' % self.get_c_type())
  426.  
  427.     
  428.     def write_error_return(self):
  429.         self.wrapper.write_code('return NULL;')
  430.  
  431.     
  432.     def write_conversion(self):
  433.         self.wrapper.write_code('retval = (%s) pygobject_get(py_retval);' % self.get_c_type())
  434.         self.wrapper.write_code('g_object_ref((GObject *) retval);')
  435.  
  436.  
  437. argtypes.matcher.register_reverse_ret('GObject*', GObjectReturn)
  438.  
  439. class IntParam(Parameter):
  440.     
  441.     def get_c_type(self):
  442.         return self.props.get('c_type', 'int')
  443.  
  444.     
  445.     def convert_c2py(self):
  446.         self.wrapper.add_declaration('PyObject *py_%s;' % self.name)
  447.         self.wrapper.write_code(code = 'py_%s = PyInt_FromLong(%s);' % (self.name, self.name), cleanup = 'Py_DECREF(py_%s);' % self.name)
  448.         self.wrapper.add_pyargv_item('py_%s' % self.name)
  449.  
  450.  
  451.  
  452. class IntReturn(ReturnType):
  453.     
  454.     def get_c_type(self):
  455.         return self.props.get('c_type', 'int')
  456.  
  457.     
  458.     def write_decl(self):
  459.         self.wrapper.add_declaration('%s retval;' % self.get_c_type())
  460.  
  461.     
  462.     def write_error_return(self):
  463.         self.wrapper.write_code('return -G_MAXINT;')
  464.  
  465.     
  466.     def write_conversion(self):
  467.         self.wrapper.write_code(code = None, failure_expression = '!PyInt_Check(py_retval)', failure_cleanup = 'PyErr_SetString(PyExc_TypeError, "retval should be an int");')
  468.         self.wrapper.write_code('retval = PyInt_AsLong(py_retval);')
  469.  
  470.  
  471. for argtype in ('int', 'gint', 'guint', 'short', 'gshort', 'gushort', 'long', 'glong', 'gsize', 'gssize', 'guint8', 'gint8', 'guint16', 'gint16', 'gint32', 'GTime'):
  472.     argtypes.matcher.register_reverse(argtype, IntParam)
  473.     argtypes.matcher.register_reverse_ret(argtype, IntReturn)
  474.  
  475.  
  476. class GEnumReturn(IntReturn):
  477.     
  478.     def write_conversion(self):
  479.         self.wrapper.write_code(code = None, failure_expression = 'pyg_enum_get_value(%s, py_retval, (gint *)&retval)' % self.props['typecode'])
  480.  
  481.  
  482. argtypes.matcher.register_reverse_ret('GEnum', GEnumReturn)
  483.  
  484. class GEnumParam(IntParam):
  485.     
  486.     def convert_c2py(self):
  487.         self.wrapper.add_declaration('PyObject *py_%s;' % self.name)
  488.         self.wrapper.write_code(code = 'py_%s = pyg_enum_from_gtype(%s, %s);' % (self.name, self.props['typecode'], self.name), cleanup = 'Py_DECREF(py_%s);' % self.name, failure_expression = '!py_%s' % self.name)
  489.         self.wrapper.add_pyargv_item('py_%s' % self.name)
  490.  
  491.  
  492. argtypes.matcher.register_reverse('GEnum', GEnumParam)
  493.  
  494. class GFlagsReturn(IntReturn):
  495.     
  496.     def write_conversion(self):
  497.         self.wrapper.write_code(code = None, failure_expression = 'pyg_flags_get_value(%s, py_retval, (gint *)&retval)' % self.props['typecode'])
  498.  
  499.  
  500. argtypes.matcher.register_reverse_ret('GFlags', GFlagsReturn)
  501.  
  502. class GFlagsParam(IntParam):
  503.     
  504.     def convert_c2py(self):
  505.         self.wrapper.add_declaration('PyObject *py_%s;' % self.name)
  506.         self.wrapper.write_code(code = 'py_%s = pyg_flags_from_gtype(%s, %s);' % (self.name, self.props['typecode'], self.name), cleanup = 'Py_DECREF(py_%s);' % self.name, failure_expression = '!py_%s' % self.name)
  507.         self.wrapper.add_pyargv_item('py_%s' % self.name)
  508.  
  509.  
  510. argtypes.matcher.register_reverse('GFlags', GFlagsParam)
  511.  
  512. class GtkTreePathParam(IntParam):
  513.     
  514.     def convert_c2py(self):
  515.         self.wrapper.add_declaration('PyObject *py_%s;' % self.name)
  516.         self.wrapper.write_code(code = 'py_%s = pygtk_tree_path_to_pyobject(%s);' % (self.name, self.name), cleanup = 'Py_DECREF(py_%s);' % self.name, failure_expression = '!py_%s' % self.name)
  517.         self.wrapper.add_pyargv_item('py_%s' % self.name)
  518.  
  519.  
  520. argtypes.matcher.register_reverse('GtkTreePath*', GtkTreePathParam)
  521.  
  522. class BooleanReturn(ReturnType):
  523.     
  524.     def get_c_type(self):
  525.         return 'gboolean'
  526.  
  527.     
  528.     def write_decl(self):
  529.         self.wrapper.add_declaration('gboolean retval;')
  530.  
  531.     
  532.     def write_error_return(self):
  533.         self.wrapper.write_code('return FALSE;')
  534.  
  535.     
  536.     def write_conversion(self):
  537.         self.wrapper.write_code('retval = PyObject_IsTrue(py_retval)? TRUE : FALSE;')
  538.  
  539.  
  540. argtypes.matcher.register_reverse_ret('gboolean', BooleanReturn)
  541.  
  542. class BooleanParam(Parameter):
  543.     
  544.     def get_c_type(self):
  545.         return 'gboolean'
  546.  
  547.     
  548.     def convert_c2py(self):
  549.         self.wrapper.add_declaration('PyObject *py_%s;' % self.name)
  550.         self.wrapper.write_code('py_%s = %s? Py_True : Py_False;' % (self.name, self.name))
  551.         self.wrapper.add_pyargv_item('py_%s' % self.name)
  552.  
  553.  
  554. argtypes.matcher.register_reverse('gboolean', BooleanParam)
  555.  
  556. class DoubleParam(Parameter):
  557.     
  558.     def get_c_type(self):
  559.         return self.props.get('c_type', 'gdouble')
  560.  
  561.     
  562.     def convert_c2py(self):
  563.         self.wrapper.add_declaration('PyObject *py_%s;' % self.name)
  564.         self.wrapper.write_code(code = 'py_%s = PyFloat_FromDouble(%s);' % (self.name, self.name), cleanup = 'Py_DECREF(py_%s);' % self.name)
  565.         self.wrapper.add_pyargv_item('py_%s' % self.name)
  566.  
  567.  
  568.  
  569. class DoubleReturn(ReturnType):
  570.     
  571.     def get_c_type(self):
  572.         return self.props.get('c_type', 'gdouble')
  573.  
  574.     
  575.     def write_decl(self):
  576.         self.wrapper.add_declaration('%s retval;' % self.get_c_type())
  577.  
  578.     
  579.     def write_error_return(self):
  580.         self.wrapper.write_code('return -G_MAXFLOAT;')
  581.  
  582.     
  583.     def write_conversion(self):
  584.         self.wrapper.write_code(code = None, failure_expression = '!PyFloat_AsDouble(py_retval)', failure_cleanup = 'PyErr_SetString(PyExc_TypeError, "retval should be a float");')
  585.         self.wrapper.write_code('retval = PyFloat_AsDouble(py_retval);')
  586.  
  587.  
  588. for argtype in ('float', 'double', 'gfloat', 'gdouble'):
  589.     argtypes.matcher.register_reverse(argtype, DoubleParam)
  590.     argtypes.matcher.register_reverse_ret(argtype, DoubleReturn)
  591.  
  592.  
  593. class GBoxedParam(Parameter):
  594.     
  595.     def get_c_type(self):
  596.         return self.props.get('c_type').replace('const-', 'const ')
  597.  
  598.     
  599.     def convert_c2py(self):
  600.         self.wrapper.add_declaration('PyObject *py_%s;' % self.name)
  601.         ctype = self.get_c_type()
  602.         if ctype.startswith('const '):
  603.             ctype_no_const = ctype[len('const '):]
  604.             self.wrapper.write_code(code = 'py_%s = pyg_boxed_new(%s, (%s) %s, TRUE, TRUE);' % (self.name, self.props['typecode'], ctype_no_const, self.name), cleanup = 'Py_DECREF(py_%s);' % self.name)
  605.         else:
  606.             self.wrapper.write_code(code = 'py_%s = pyg_boxed_new(%s, %s, FALSE, FALSE);' % (self.name, self.props['typecode'], self.name), cleanup = 'Py_DECREF(py_%s);' % self.name)
  607.         self.wrapper.add_pyargv_item('py_%s' % self.name)
  608.  
  609.  
  610. argtypes.matcher.register_reverse('GBoxed', GBoxedParam)
  611.  
  612. class GBoxedReturn(ReturnType):
  613.     
  614.     def get_c_type(self):
  615.         return self.props.get('c_type')
  616.  
  617.     
  618.     def write_decl(self):
  619.         self.wrapper.add_declaration('%s retval;' % self.get_c_type())
  620.  
  621.     
  622.     def write_error_return(self):
  623.         self.wrapper.write_code('return retval;')
  624.  
  625.     
  626.     def write_conversion(self):
  627.         self.wrapper.write_code(failure_expression = '!pyg_boxed_check(py_retval, %s)' % (self.props['typecode'],), failure_cleanup = 'PyErr_SetString(PyExc_TypeError, "retval should be a %s");' % (self.props['typename'],))
  628.         self.wrapper.write_code('retval = pyg_boxed_get(py_retval, %s);' % self.props['typename'])
  629.  
  630.  
  631. argtypes.matcher.register_reverse_ret('GBoxed', GBoxedReturn)
  632.  
  633. class GdkRectanglePtrParam(Parameter):
  634.     
  635.     def get_c_type(self):
  636.         return self.props.get('c_type').replace('const-', 'const ')
  637.  
  638.     
  639.     def convert_c2py(self):
  640.         self.wrapper.add_declaration('PyObject *py_%s;' % self.name)
  641.         self.wrapper.write_code(code = 'py_%(name)s = Py_BuildValue("(ffff)", %(name)s->x, %(name)s->y,\n                            %(name)s->width, %(name)s->height);' % dict(name = self.name), cleanup = 'Py_DECREF(py_%s);' % self.name)
  642.         self.wrapper.add_pyargv_item('py_%s' % self.name)
  643.  
  644.  
  645. argtypes.matcher.register_reverse('GdkRectangle*', GdkRectanglePtrParam)
  646.  
  647. class PyGObjectMethodParam(Parameter):
  648.     
  649.     def __init__(self, wrapper, name, method_name, **props):
  650.         Parameter.__init__(self, wrapper, name, **props)
  651.         self.method_name = method_name
  652.  
  653.     
  654.     def get_c_type(self):
  655.         return self.props.get('c_type', 'GObject *')
  656.  
  657.     
  658.     def convert_c2py(self):
  659.         self.wrapper.add_declaration('PyObject *py_%s;' % self.name)
  660.         self.wrapper.write_code(code = 'py_%s = pygobject_new((GObject *) %s);' % (self.name, self.name), cleanup = 'Py_DECREF(py_%s);' % self.name, failure_expression = '!py_%s' % self.name)
  661.         self.wrapper.set_call_target('py_%s' % self.name, self.method_name)
  662.  
  663.  
  664.  
  665. class CallbackInUserDataParam(Parameter):
  666.     
  667.     def __init__(self, wrapper, name, free_it, **props):
  668.         Parameter.__init__(self, wrapper, name, **props)
  669.         self.free_it = free_it
  670.  
  671.     
  672.     def get_c_type(self):
  673.         return 'gpointer'
  674.  
  675.     
  676.     def convert_c2py(self):
  677.         self.wrapper.add_declaration('PyObject **_user_data;')
  678.         if not self.free_it or 'g_free(%s);' % self.name:
  679.             pass
  680.         cleanup = None
  681.         self.wrapper.write_code(code = '_real_user_data = (PyObject **) %s;' % self.name, cleanup = cleanup)
  682.         self.wrapper.add_declaration('PyObject *py_func;')
  683.         if not self.free_it or 'Py_DECREF(py_func);':
  684.             pass
  685.         cleanup = None
  686.         self.wrapper.write_code(code = 'py_func = _user_data[0];', cleanup = cleanup)
  687.         self.wrapper.set_call_target('py_func')
  688.         self.wrapper.add_declaration('PyObject *py_user_data;')
  689.         if not self.free_it or 'Py_XDECREF(py_user_data);':
  690.             pass
  691.         cleanup = None
  692.         self.wrapper.write_code(code = 'py_user_data = _user_data[1];', cleanup = cleanup)
  693.         self.wrapper.add_pyargv_item('py_user_data', optional = True)
  694.  
  695.  
  696.  
  697. def _test():
  698.     import sys as sys
  699.     wrapper = ReverseWrapper('this_is_the_c_function_name', is_static = True)
  700.     wrapper.set_return_type(StringReturn(wrapper))
  701.     wrapper.add_parameter(PyGObjectMethodParam(wrapper, 'self', method_name = 'do_xxx'))
  702.     wrapper.add_parameter(StringParam(wrapper, 'param2', optional = True))
  703.     wrapper.add_parameter(GObjectParam(wrapper, 'param3'))
  704.     wrapper.generate(FileCodeSink(sys.stderr))
  705.     wrapper = ReverseWrapper('this_a_callback_wrapper')
  706.     wrapper.set_return_type(VoidReturn(wrapper))
  707.     wrapper.add_parameter(StringParam(wrapper, 'param1', optional = False))
  708.     wrapper.add_parameter(GObjectParam(wrapper, 'param2'))
  709.     wrapper.add_parameter(CallbackInUserDataParam(wrapper, 'data', free_it = True))
  710.     wrapper.generate(FileCodeSink(sys.stderr))
  711.  
  712. if __name__ == '__main__':
  713.     _test()
  714.  
  715.